home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / pprint.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  7KB  |  297 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import sys as _sys
  5. from cStringIO import StringIO as _StringIO
  6. __all__ = [
  7.     'pprint',
  8.     'pformat',
  9.     'isreadable',
  10.     'isrecursive',
  11.     'saferepr',
  12.     'PrettyPrinter']
  13. _commajoin = ', '.join
  14. _id = id
  15. _len = len
  16. _type = type
  17.  
  18. def pprint(object, stream = None, indent = 1, width = 80, depth = None):
  19.     printer = PrettyPrinter(stream = stream, indent = indent, width = width, depth = depth)
  20.     printer.pprint(object)
  21.  
  22.  
  23. def pformat(object, indent = 1, width = 80, depth = None):
  24.     return PrettyPrinter(indent = indent, width = width, depth = depth).pformat(object)
  25.  
  26.  
  27. def saferepr(object):
  28.     return _safe_repr(object, { }, None, 0)[0]
  29.  
  30.  
  31. def isreadable(object):
  32.     return _safe_repr(object, { }, None, 0)[1]
  33.  
  34.  
  35. def isrecursive(object):
  36.     return _safe_repr(object, { }, None, 0)[2]
  37.  
  38.  
  39. class PrettyPrinter:
  40.     
  41.     def __init__(self, indent = 1, width = 80, depth = None, stream = None):
  42.         indent = int(indent)
  43.         width = int(width)
  44.         self._depth = depth
  45.         self._indent_per_level = indent
  46.         self._width = width
  47.         if stream is not None:
  48.             self._stream = stream
  49.         else:
  50.             self._stream = _sys.stdout
  51.  
  52.     
  53.     def pprint(self, object):
  54.         self._format(object, self._stream, 0, 0, { }, 0)
  55.         self._stream.write('\n')
  56.  
  57.     
  58.     def pformat(self, object):
  59.         sio = _StringIO()
  60.         self._format(object, sio, 0, 0, { }, 0)
  61.         return sio.getvalue()
  62.  
  63.     
  64.     def isrecursive(self, object):
  65.         return self.format(object, { }, 0, 0)[2]
  66.  
  67.     
  68.     def isreadable(self, object):
  69.         (s, readable, recursive) = self.format(object, { }, 0, 0)
  70.         if readable:
  71.             pass
  72.         return not recursive
  73.  
  74.     
  75.     def _format(self, object, stream, indent, allowance, context, level):
  76.         level = level + 1
  77.         objid = _id(object)
  78.         if objid in context:
  79.             stream.write(_recursion(object))
  80.             self._recursive = True
  81.             self._readable = False
  82.             return None
  83.         
  84.         rep = self._repr(object, context, level - 1)
  85.         typ = _type(object)
  86.         sepLines = _len(rep) > self._width - 1 - indent - allowance
  87.         write = stream.write
  88.         if sepLines:
  89.             r = getattr(typ, '__repr__', None)
  90.             if issubclass(typ, dict) and r is dict.__repr__:
  91.                 write('{')
  92.                 if self._indent_per_level > 1:
  93.                     write((self._indent_per_level - 1) * ' ')
  94.                 
  95.                 length = _len(object)
  96.                 if length:
  97.                     context[objid] = 1
  98.                     indent = indent + self._indent_per_level
  99.                     items = object.items()
  100.                     items.sort()
  101.                     (key, ent) = items[0]
  102.                     rep = self._repr(key, context, level)
  103.                     write(rep)
  104.                     write(': ')
  105.                     self._format(ent, stream, indent + _len(rep) + 2, allowance + 1, context, level)
  106.                     if length > 1:
  107.                         for key, ent in items[1:]:
  108.                             rep = self._repr(key, context, level)
  109.                             write(',\n%s%s: ' % (' ' * indent, rep))
  110.                             self._format(ent, stream, indent + _len(rep) + 2, allowance + 1, context, level)
  111.                         
  112.                     
  113.                     indent = indent - self._indent_per_level
  114.                     del context[objid]
  115.                 
  116.                 write('}')
  117.                 return None
  118.             
  119.             if (issubclass(typ, list) or r is list.__repr__ or issubclass(typ, tuple)) and r is tuple.__repr__:
  120.                 if issubclass(typ, list):
  121.                     write('[')
  122.                     endchar = ']'
  123.                 else:
  124.                     write('(')
  125.                     endchar = ')'
  126.                 if self._indent_per_level > 1:
  127.                     write((self._indent_per_level - 1) * ' ')
  128.                 
  129.                 length = _len(object)
  130.                 if length:
  131.                     context[objid] = 1
  132.                     indent = indent + self._indent_per_level
  133.                     self._format(object[0], stream, indent, allowance + 1, context, level)
  134.                     if length > 1:
  135.                         for ent in object[1:]:
  136.                             write(',\n' + ' ' * indent)
  137.                             self._format(ent, stream, indent, allowance + 1, context, level)
  138.                         
  139.                     
  140.                     indent = indent - self._indent_per_level
  141.                     del context[objid]
  142.                 
  143.                 if issubclass(typ, tuple) and length == 1:
  144.                     write(',')
  145.                 
  146.                 write(endchar)
  147.                 return None
  148.             
  149.         
  150.         write(rep)
  151.  
  152.     
  153.     def _repr(self, object, context, level):
  154.         (repr, readable, recursive) = self.format(object, context.copy(), self._depth, level)
  155.         if not readable:
  156.             self._readable = False
  157.         
  158.         if recursive:
  159.             self._recursive = True
  160.         
  161.         return repr
  162.  
  163.     
  164.     def format(self, object, context, maxlevels, level):
  165.         return _safe_repr(object, context, maxlevels, level)
  166.  
  167.  
  168.  
  169. def _safe_repr(object, context, maxlevels, level):
  170.     typ = _type(object)
  171.     if typ is str:
  172.         if 'locale' not in _sys.modules:
  173.             return (repr(object), True, False)
  174.         
  175.         if "'" in object and '"' not in object:
  176.             closure = '"'
  177.             quotes = {
  178.                 '"': '\\"' }
  179.         else:
  180.             closure = "'"
  181.             quotes = {
  182.                 "'": "\\'" }
  183.         qget = quotes.get
  184.         sio = _StringIO()
  185.         write = sio.write
  186.         for char in object:
  187.             if char.isalpha():
  188.                 write(char)
  189.                 continue
  190.             write(qget(char, repr(char)[1:-1]))
  191.         
  192.         return ('%s%s%s' % (closure, sio.getvalue(), closure), True, False)
  193.     
  194.     r = getattr(typ, '__repr__', None)
  195.     if issubclass(typ, dict) and r is dict.__repr__:
  196.         if not object:
  197.             return ('{}', True, False)
  198.         
  199.         objid = _id(object)
  200.         if maxlevels and level > maxlevels:
  201.             return ('{...}', False, objid in context)
  202.         
  203.         if objid in context:
  204.             return (_recursion(object), False, True)
  205.         
  206.         context[objid] = 1
  207.         readable = True
  208.         recursive = False
  209.         components = []
  210.         append = components.append
  211.         level += 1
  212.         saferepr = _safe_repr
  213.         for k, v in sorted(object.items()):
  214.             (krepr, kreadable, krecur) = saferepr(k, context, maxlevels, level)
  215.             (vrepr, vreadable, vrecur) = saferepr(v, context, maxlevels, level)
  216.             append('%s: %s' % (krepr, vrepr))
  217.             if readable and kreadable:
  218.                 pass
  219.             readable = vreadable
  220.             if krecur or vrecur:
  221.                 recursive = True
  222.                 continue
  223.         
  224.         del context[objid]
  225.         return ('{%s}' % _commajoin(components), readable, recursive)
  226.     
  227.     if (issubclass(typ, list) or r is list.__repr__ or issubclass(typ, tuple)) and r is tuple.__repr__:
  228.         if issubclass(typ, list):
  229.             if not object:
  230.                 return ('[]', True, False)
  231.             
  232.             format = '[%s]'
  233.         elif _len(object) == 1:
  234.             format = '(%s,)'
  235.         elif not object:
  236.             return ('()', True, False)
  237.         
  238.         format = '(%s)'
  239.         objid = _id(object)
  240.         if maxlevels and level > maxlevels:
  241.             return (format % '...', False, objid in context)
  242.         
  243.         if objid in context:
  244.             return (_recursion(object), False, True)
  245.         
  246.         context[objid] = 1
  247.         readable = True
  248.         recursive = False
  249.         components = []
  250.         append = components.append
  251.         level += 1
  252.         for o in object:
  253.             (orepr, oreadable, orecur) = _safe_repr(o, context, maxlevels, level)
  254.             append(orepr)
  255.             if not oreadable:
  256.                 readable = False
  257.             
  258.             if orecur:
  259.                 recursive = True
  260.                 continue
  261.         
  262.         del context[objid]
  263.         return (format % _commajoin(components), readable, recursive)
  264.     
  265.     rep = repr(object)
  266.     if rep:
  267.         pass
  268.     return (rep, not rep.startswith('<'), False)
  269.  
  270.  
  271. def _recursion(object):
  272.     return '<Recursion on %s with id=%s>' % (_type(object).__name__, _id(object))
  273.  
  274.  
  275. def _perfcheck(object = None):
  276.     import time as time
  277.     if object is None:
  278.         object = [
  279.             ('string', (1, 2), [
  280.                 3,
  281.                 4], {
  282.                 5: 6,
  283.                 7: 8 })] * 100000
  284.     
  285.     p = PrettyPrinter()
  286.     t1 = time.time()
  287.     _safe_repr(object, { }, None, 0)
  288.     t2 = time.time()
  289.     p.pformat(object)
  290.     t3 = time.time()
  291.     print '_safe_repr:', t2 - t1
  292.     print 'pformat:', t3 - t2
  293.  
  294. if __name__ == '__main__':
  295.     _perfcheck()
  296.  
  297.